#include "Functions.h"
#include <glade/glade.h>
#include <gdk/gdk.h>
#include <stdlib.h>
#include <fstream>
#include <sstream>
#include <string.h>
#include "i18n.h"
#include "Utils.h"
#include "Config.h"
#include "Run.h"
#include "OptParser.h"

#define ICON_DEFAULT PIXMAPDIR "/" PACKAGE_NAME ".png"

static const gchar *authors[] = { "Yadickson Soto <yadickson@gmail.com>",
                                  "Rodolfo Granata <warlock.cc@gmail.com>",
                                  "Ivan Fitenko <ivan.fitenko@eltrino.com>",
                                  NULL };

static const gchar *documenters[] = { "Yadickson Soto <yadickson@gmail.com>",
                                      NULL };

static const gchar *translater =
    "Español - Yadickson Soto <yadickson@gmail.com>\nDeutsch - Daniel "
    "MeissWilhelm <meisssw01@googlemail.com>";

static GladeXML *xml = NULL;
static bool edit = false;
std::string configFile;

enum GrowIcons {
  GROW_NORMAL,
  GROW_INVERTED
};

enum Positions {
  POS_TOP,
  POS_BOTTOM,
  POS_LEFT,
  POS_RIGHT,
  POS_CENTER,
  POS_BOTTOM_LEFT,
  POS_BOTTOM_RIGHT,
  POS_TOP_LEFT,
  POS_TOP_RIGHT
};

enum Filters {
  FILTER_NONE,
  FILTER_HOVERED,
  FILTER_OTHERS,
  FILTER_ALL
};

enum {
  TREE_COLUMN_ICON,
  TREE_COLUMN_TITLE,
  TREE_COLUMN_COMMAND,
  TREE_COLUMN_ICON_NAME,
  TREE_COLUMNS
};

enum {
  COMBO_COLUMN_TEXT,
  COMBO_COLUMN_ID,
  COMBO_COLUMNS
};

enum {
  ICON_COLUMN_PIXBUF,
  ICON_COLUMN_TEXT,
  ICON_COLUMN_ID,
  ICON_COLUMNS
};

void view_settings() {
  glade_init();
  xml = glade_xml_new(GLADE_PACKAGE_NAME, NULL, NULL);

  set_default_icon();

  GtkWidget *settings = glade_xml_get_widget(xml, "dialog_settings");
  gtk_widget_show(GTK_WIDGET(settings));
  gtk_widget_show_all(settings);

  set_signals();
  set_treeview();
  set_comboboxs();
  set_config();
  update_treeview();
}

void set_default_icon() {
  GdkPixbuf *pixbuf;
  pixbuf = gdk_pixbuf_new_from_file(ICON_DEFAULT, NULL);
  gtk_window_set_default_icon(pixbuf);
  g_object_unref(pixbuf);
}

void set_treeview() {
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");
  GtkListStore *list_store =
      gtk_list_store_new(TREE_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING,
                         G_TYPE_STRING, G_TYPE_STRING);
  gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(list_store));

  GtkTreeViewColumn *column;
  GtkCellRenderer *renderer;

  renderer = gtk_cell_renderer_pixbuf_new();
  column = gtk_tree_view_column_new_with_attributes(
      _("Icon"), renderer, "pixbuf", TREE_COLUMN_ICON, (char *)NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);

  renderer = gtk_cell_renderer_text_new();
  column = gtk_tree_view_column_new_with_attributes(
      _("Title"), renderer, "markup", TREE_COLUMN_TITLE, (char *)NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);

  renderer = gtk_cell_renderer_text_new();
  column = gtk_tree_view_column_new_with_attributes(
      _("Command"), renderer, "markup", TREE_COLUMN_COMMAND, (char *)NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
}

void set_comboboxs() {
  GtkWidget *combo;
  GtkListStore *list_store;
  GtkTreeIter iter;
  GtkCellRenderer *cell;

  combo = glade_xml_get_widget(xml, "combobox_pos");
  list_store = gtk_list_store_new(COMBO_COLUMNS, G_TYPE_STRING, G_TYPE_INT);
  gtk_combo_box_set_model(GTK_COMBO_BOX(combo), GTK_TREE_MODEL(list_store));

  cell = gtk_cell_renderer_text_new();
  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE);
  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, "text", 0,
                                 (char *)NULL);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("top"),
                     COMBO_COLUMN_ID, POS_TOP, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("bottom"),
                     COMBO_COLUMN_ID, POS_BOTTOM, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("left"),
                     COMBO_COLUMN_ID, POS_LEFT, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("right"),
                     COMBO_COLUMN_ID, POS_RIGHT, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("center"),
                     COMBO_COLUMN_ID, POS_CENTER, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("bot-left"),
                     COMBO_COLUMN_ID, POS_BOTTOM_LEFT, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("bot-right"),
                     COMBO_COLUMN_ID, POS_BOTTOM_RIGHT, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("top-left"),
                     COMBO_COLUMN_ID, POS_TOP_LEFT, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("top-right"),
                     COMBO_COLUMN_ID, POS_TOP_RIGHT, -1);

  gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_RIGHT);

  combo = glade_xml_get_widget(xml, "combobox_filter");
  list_store = gtk_list_store_new(COMBO_COLUMNS, G_TYPE_STRING, G_TYPE_INT);
  gtk_combo_box_set_model(GTK_COMBO_BOX(combo), GTK_TREE_MODEL(list_store));

  cell = gtk_cell_renderer_text_new();
  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE);
  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, "text", 0,
                                 (char *)NULL);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("none"),
                     COMBO_COLUMN_ID, FILTER_NONE, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("hovered"),
                     COMBO_COLUMN_ID, FILTER_HOVERED, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("others"),
                     COMBO_COLUMN_ID, FILTER_OTHERS, -1);

  gtk_list_store_append(list_store, &iter);
  gtk_list_store_set(list_store, &iter, COMBO_COLUMN_TEXT, _("all"),
                     COMBO_COLUMN_ID, FILTER_ALL, -1);

  gtk_combo_box_set_active(GTK_COMBO_BOX(combo), FILTER_NONE);

}

void set_config() {
  Config config;
  std::list<App *> list = config.getAppList();

  if (list.empty()) {
    return;
  }

  std::list<App *>::iterator it;
  it = list.begin();

  App *app = (*it);

  if (app) {
    Utils util;
    std::string font = app->getTitle();
    int size = 10;
    std::list<std::string> f = util.split(font, "/");

    try {
      size = (f.size() > 1 ? (int) strtold(f.back().c_str(), NULL) : 10);
      f.pop_back();
    }
    catch (...) {
    }

    font = util.join(f, "/");

    GtkWidget *spinbutton_font_size =
        glade_xml_get_widget(xml, "spinbutton_font_size");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton_font_size), size);

    GtkWidget *entry_font_name = glade_xml_get_widget(xml, "entry_font_name");
    gtk_entry_set_text(GTK_ENTRY(entry_font_name), font.c_str());

    GtkWidget *entry_image_name = glade_xml_get_widget(xml, "entry_image_name");
    gtk_entry_set_text(GTK_ENTRY(entry_image_name), app->getIconName().c_str());

    set_config_states(app->getCommand());
    delete app;
  }

}

void set_config_states(std::string command) {
  GtkWidget *checkbutton = NULL;
  GtkWidget *spinbutton = NULL;

  Run run;
  int argc;
  char **argv = run.getArg(argc);

  if (argc <= 1) {
    std::list<std::string> list;
    Utils util;
    list = util.split(command, " ");
    argc = list.size();

    if (argc > 1) {
      std::list<std::string>::iterator ac;
      argv = new char *[argc + 1];
      int i = 0;

      for (ac = list.begin(); ac != list.end(); ac++, i++) {
        argv[i] = strdup((*ac).c_str());
      }

      argv[argc] = NULL;
    }
  }

  OptParser tmpoptparser(argc, argv);

  if (tmpoptparser.isSet(OptParser::CONFIG)) {
    configFile = tmpoptparser.getArg(OptParser::CONFIG);
    Config config;
    config.setFile(configFile);
    config.getAppList();

    std::list<App *> list = config.getAppList();
    std::list<App *>::iterator it;
    App *p;

    if (!list.empty()) {
      it = list.begin();
      p = (*it);
    } else {
      throw _("Configuration empty.");
    }

    command = p->getCommand();
    delete p;

    if (command.empty()) {
      command = PACKAGE_NAME " " DEFAULT_ARGV;
    }

    if (argc <= 1 || tmpoptparser.isSet(OptParser::CONFIG)) {
      std::list<std::string> list;
      Utils util;
      list = util.split(command, " ");
      argc = list.size();

      if (argc > 1) {
        if (argc > 0) {
          delete[] argv;
        }

        std::list<std::string>::iterator ac;
        argv = new char *[argc + 1];
        int i = 0;

        for (ac = list.begin(); ac != list.end(); ac++, i++) {
          argv[i] = strdup((*ac).c_str());
        }

        argv[argc] = NULL;
      }
    }
  }

  OptParser opt(argc, argv);

  if (opt.isSet(OptParser::BPRESS)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_bpress");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::ABOVE_DESK)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_above_desk");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::VBAR)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_vbar");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::NOFONT)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_nofont");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::POS)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_pos");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    GtkWidget *combo = glade_xml_get_widget(xml, "combobox_pos");

    std::string pos = opt.getArg(OptParser::POS);

    if (pos == "top") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_TOP);
    } else if (pos == "bottom") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_BOTTOM);
    } else if (pos == "left") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_LEFT);
    } else if (pos == "center") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_CENTER);
    } else if (pos == "bot-left") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_BOTTOM_LEFT);
    } else if (pos == "bot-right") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_BOTTOM_RIGHT);
    } else if (pos == "top-left") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_TOP_LEFT);
    } else if (pos == "top-right") {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_TOP_RIGHT);
    } else /*if (pos == "right")*/
        {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), POS_RIGHT);
    }
  }

  if (opt.isSet(OptParser::GROW)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_grow");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::OFFSET)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_offset");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_offset");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::OFFSET).c_str()));
  }

  if (opt.isSet(OptParser::NORELOAD)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_noreload");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::TASKBAR)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_taskbar");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
  }

  if (opt.isSet(OptParser::RSIZE)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_rsize");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_rsize");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::RSIZE).c_str()));
  }

  if (opt.isSet(OptParser::ISIZE)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_isize");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_isize");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::ISIZE).c_str()));
  }

  if (opt.isSet(OptParser::IDIST)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_idist");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_idist");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::IDIST).c_str()));
  }

  if (opt.isSet(OptParser::NANIM)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_nanim");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_nanim");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::NANIM).c_str()));
  }

  if (opt.isSet(OptParser::ZOOMF)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_zoomf");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_zoomf");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atof(opt.getArg(OptParser::ZOOMF).c_str()));
  }

  if (opt.isSet(OptParser::JUMPF)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_jumpf");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_jumpf");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atof(opt.getArg(OptParser::JUMPF).c_str()));
  }

  if (opt.isSet(OptParser::DBLCLK)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_dblclk");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_dblclk");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::DBLCLK).c_str()));
  }

  if (opt.isSet(OptParser::BALFA)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_balfa");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_balfa");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::BALFA).c_str()));
  }

  if (opt.isSet(OptParser::FALFA)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_falfa");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    spinbutton = glade_xml_get_widget(xml, "spinbutton_falfa");
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton),
                              atoi(opt.getArg(OptParser::FALFA).c_str()));
  }

  if (opt.isSet(OptParser::FILTER)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_filter");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);
    GtkWidget *combo = glade_xml_get_widget(xml, "combobox_filter");

    std::string filter = opt.getArg(OptParser::FILTER);
    int f;
    std::stringstream ss(filter);
    ss >> f;

    if (f == 1) {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), FILTER_HOVERED);
    } else if (f == 2) {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), FILTER_OTHERS);
    } else if (f == 3) {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), FILTER_ALL);
    } else /*if (filter == "none")*/
        {
      gtk_combo_box_set_active(GTK_COMBO_BOX(combo), FILTER_NONE);
    }
  }

  if (opt.isSet(OptParser::FC)) {
    checkbutton = glade_xml_get_widget(xml, "checkbutton_fc");
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), true);

    std::string scolor = opt.getArg(OptParser::FC);
    std::string salpha = scolor.substr(2, 2);
    scolor = "#" + scolor.substr(4, 6);

    GdkColor rgb;
    GtkWidget *color = glade_xml_get_widget(xml, "colorbutton_fc");

    gdk_color_parse(scolor.c_str(), &rgb);
    gtk_color_button_set_color(GTK_COLOR_BUTTON(color), &rgb);
    gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(color), TRUE);
    gtk_color_button_set_alpha(GTK_COLOR_BUTTON(color),
                               256 * (strtol(salpha.c_str(), NULL, 16) + 0.5));
  }

  if (argc > 0) {
    delete[] argv;
  }
}

void set_signals() {

  glade_xml_signal_connect(xml, "on_dialog_settings_destroy",
                           (GCallback) on_settings_close);

  glade_xml_signal_connect(xml, "on_menu_item_new_activate",
                           (GCallback) on_settings_new);
  glade_xml_signal_connect(xml, "on_menu_item_edit_activate",
                           (GCallback) on_settings_edit);
  glade_xml_signal_connect(xml, "on_menu_item_delete_activate",
                           (GCallback) on_settings_delete);

  glade_xml_signal_connect(xml, "on_button_new_clicked",
                           (GCallback) on_settings_new);
  glade_xml_signal_connect(xml, "on_button_edit_clicked",
                           (GCallback) on_settings_edit);
  glade_xml_signal_connect(xml, "on_button_delete_clicked",
                           (GCallback) on_settings_delete);

  glade_xml_signal_connect(xml, "on_button_up_activate", (GCallback) on_app_up);
  glade_xml_signal_connect(xml, "on_button_up_released", (GCallback) on_app_up);

  glade_xml_signal_connect(xml, "on_button_down_activate",
                           (GCallback) on_app_down);
  glade_xml_signal_connect(xml, "on_button_down_released",
                           (GCallback) on_app_down);

  glade_xml_signal_connect(xml, "on_button_app_accept_activate",
                           (GCallback) on_app_accept);
  glade_xml_signal_connect(xml, "on_button_app_accept_released",
                           (GCallback) on_app_accept);

  glade_xml_signal_connect(xml, "on_button_app_cancel_activate",
                           (GCallback) on_app_cancel);
  glade_xml_signal_connect(xml, "on_button_app_cancel_released",
                           (GCallback) on_app_cancel);

  glade_xml_signal_connect(xml, "on_button_update_activate",
                           (GCallback) on_settings_update);
  glade_xml_signal_connect(xml, "on_button_update_released",
                           (GCallback) on_settings_update);

  glade_xml_signal_connect(xml, "on_button_close_activate",
                           (GCallback) on_settings_close);
  glade_xml_signal_connect(xml, "on_button_close_released",
                           (GCallback) on_settings_close);

  glade_xml_signal_connect(xml, "on_menu_item_edit_activate",
                           (GCallback) on_settings_edit);
  glade_xml_signal_connect(xml, "on_menu_item_delete_activate",
                           (GCallback) on_settings_delete);

  glade_xml_signal_connect(xml, "on_button_command_activate",
                           (GCallback) on_select_command);
  glade_xml_signal_connect(xml, "on_button_command_released",
                           (GCallback) on_select_command);

  glade_xml_signal_connect(xml, "on_button_icon_activate",
                           (GCallback) on_select_icon);
  glade_xml_signal_connect(xml, "on_button_icon_released",
                           (GCallback) on_select_icon);

  glade_xml_signal_connect(xml, "on_button_image_name_activate",
                           (GCallback) on_select_imagename);
  glade_xml_signal_connect(xml, "on_button_image_name_released",
                           (GCallback) on_select_imagename);

  glade_xml_signal_connect(xml, "on_button_font_name_activate",
                           (GCallback) on_select_fontname);
  glade_xml_signal_connect(xml, "on_button_font_name_released",
                           (GCallback) on_select_fontname);

  glade_xml_signal_connect(xml, "on_treeview_app_cursor_changed",
                           (GCallback) on_treeview_cursor_changed);
  glade_xml_signal_connect(xml, "on_combobox_icon_changed",
                           (GCallback) on_icon_changed);

  glade_xml_signal_connect(xml, "on_button_about_activate",
                           (GCallback) show_about);
  glade_xml_signal_connect(xml, "on_button_about_released",
                           (GCallback) show_about);

  GtkWidget *check;
  GtkWidget *widget;

  check = glade_xml_get_widget(xml, "checkbutton_pos");
  widget = glade_xml_get_widget(xml, "combobox_pos");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_offset");
  widget = glade_xml_get_widget(xml, "spinbutton_offset");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_rsize");
  widget = glade_xml_get_widget(xml, "spinbutton_rsize");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_isize");
  widget = glade_xml_get_widget(xml, "spinbutton_isize");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_idist");
  widget = glade_xml_get_widget(xml, "spinbutton_idist");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_nanim");
  widget = glade_xml_get_widget(xml, "spinbutton_nanim");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_zoomf");
  widget = glade_xml_get_widget(xml, "spinbutton_zoomf");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_jumpf");
  widget = glade_xml_get_widget(xml, "spinbutton_jumpf");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_dblclk");
  widget = glade_xml_get_widget(xml, "spinbutton_dblclk");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_balfa");
  widget = glade_xml_get_widget(xml, "spinbutton_balfa");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_falfa");
  widget = glade_xml_get_widget(xml, "spinbutton_falfa");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_filter");
  widget = glade_xml_get_widget(xml, "combobox_filter");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  check = glade_xml_get_widget(xml, "checkbutton_fc");
  widget = glade_xml_get_widget(xml, "colorbutton_fc");
  g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(checkbutton_toggled),
                   widget);

  widget = glade_xml_get_widget(xml, "treeview_app");
  GtkWidget *menu = glade_xml_get_widget(xml, "menu_popup");
  g_signal_connect(G_OBJECT(widget), "button-release-event",
                   G_CALLBACK(clickTreeView), menu);
}

void update_treeview() {
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");
  GtkListStore *list_store =
      GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)));

  gtk_list_store_clear(list_store);

  GtkTreeIter iter;
  GdkPixbuf *pix;

  Config config;
  std::list<App *> list = config.getAppList();
  std::list<App *>::iterator it;

  for (it = list.begin(), it++; it != list.end(); it++) {
    App *app = (*it);

    if (app) {
      pix = get_icon(app->getIconName());
      gtk_list_store_append(list_store, &iter);
      gtk_list_store_set(list_store, &iter, TREE_COLUMN_ICON, pix,
                         TREE_COLUMN_TITLE, app->getTitle().c_str(),
                         TREE_COLUMN_COMMAND, app->getCommand().c_str(),
                         TREE_COLUMN_ICON_NAME, app->getIconName().c_str(), -1);
      g_object_unref(pix);
      delete app;
    }
  }

  list.clear();
}

GdkPixbuf *get_icon(std::string icon) { return get_icon_size(icon, 32, 32); }

GdkPixbuf *get_icon_size(std::string icon, int width, int heigth) {
  if (icon.length() == 0) {
    return NULL;
  }

  GdkPixbuf *pixbuf = NULL;

  try {
    GError *error = NULL;
    pixbuf = gdk_pixbuf_new_from_file(icon.c_str(), &error);

    if (!pixbuf) {
      g_error_free(error);
      return NULL;
    }

    GdkPixbuf *pixbuf_scaled = NULL;
    pixbuf_scaled =
        gdk_pixbuf_scale_simple(pixbuf, width, heigth, GDK_INTERP_BILINEAR);
    g_object_unref(pixbuf);

    return pixbuf_scaled;
  }
  catch (...) {
  }

  return NULL;
}

void on_settings_new() {
  edit = false;

  GtkWidget *title = glade_xml_get_widget(xml, "entry_title");
  GtkWidget *command = glade_xml_get_widget(xml, "entry_command");
  GtkWidget *icon = glade_xml_get_widget(xml, "entry_icon");

  gtk_entry_set_text(GTK_ENTRY(title), "");
  gtk_entry_set_text(GTK_ENTRY(command), "");
  gtk_entry_set_text(GTK_ENTRY(icon), "");

  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_app");
  gtk_window_set_title(GTK_WINDOW(dialog), _("New"));
  g_signal_connect(G_OBJECT(dialog), "delete-event", G_CALLBACK(widget_hide),
                   NULL);
  gtk_widget_show(dialog);
}

void on_settings_edit() {
  edit = true;
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");

  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
    GtkWidget *title = glade_xml_get_widget(xml, "entry_title");
    GtkWidget *command = glade_xml_get_widget(xml, "entry_command");
    GtkWidget *icon = glade_xml_get_widget(xml, "entry_icon");

    gchar *name;

    gtk_tree_model_get(model, &iter, TREE_COLUMN_TITLE, &name, -1);
    gtk_entry_set_text(GTK_ENTRY(title), name);
    g_free(name);

    gtk_tree_model_get(model, &iter, TREE_COLUMN_COMMAND, &name, -1);
    gtk_entry_set_text(GTK_ENTRY(command), name);
    g_free(name);

    gtk_tree_model_get(model, &iter, TREE_COLUMN_ICON_NAME, &name, -1);
    gtk_entry_set_text(GTK_ENTRY(icon), name);
    g_free(name);

    GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_app");
    gtk_window_set_title(GTK_WINDOW(dialog), _("Edit"));
    g_signal_connect(G_OBJECT(dialog), "delete-event", G_CALLBACK(widget_hide),
                     NULL);
    gtk_widget_show(dialog);
  }
}

void on_settings_delete() {
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");

  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
    gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
    set_status_button();
  }
}

void on_settings_update() {
  Config config;
  std::string filename = configFile.empty() ? config.getFile() : configFile;
  std::ofstream file(filename.c_str());

  if (!file.is_open()) {
    GtkWidget *dialog = gtk_message_dialog_new(
        GTK_WINDOW(glade_xml_get_widget(xml, "dialog_settings")),
        GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s",
        (_("Error save config in ") + filename).c_str());

    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
  }

  GtkWidget *spinbutton;
  GtkWidget *entry;

  std::string imageName, fontName;
  int fontSize;

  spinbutton = glade_xml_get_widget(xml, "spinbutton_font_size");
  fontSize = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton));

  entry = glade_xml_get_widget(xml, "entry_font_name");
  fontName = gtk_entry_get_text(GTK_ENTRY(entry));

  entry = glade_xml_get_widget(xml, "entry_image_name");
  imageName = gtk_entry_get_text(GTK_ENTRY(entry));

  std::string fullcommand = getCommand();

  file << "i: " << imageName << std::endl;
  file << "c: " << fullcommand << std::endl;
  file << "t: " << fontName << "/" << fontSize << std::endl;
  file << std::endl;

  GtkTreeIter iter;
  gboolean valid;

  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");
  GtkListStore *list_store =
      GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)));

  valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list_store), &iter);

  while (valid) {
    gchar *icon, *command, *title;

    gtk_tree_model_get(GTK_TREE_MODEL(list_store), &iter, TREE_COLUMN_ICON_NAME,
                       &icon, -1);
    gtk_tree_model_get(GTK_TREE_MODEL(list_store), &iter, TREE_COLUMN_COMMAND,
                       &command, -1);
    gtk_tree_model_get(GTK_TREE_MODEL(list_store), &iter, TREE_COLUMN_TITLE,
                       &title, -1);

    file << "i: " << icon << std::endl;
    file << "c: " << command << std::endl;
    file << "t: " << title << std::endl;
    file << std::endl;

    g_free(icon);
    g_free(command);
    g_free(title);

    valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store), &iter);
  }

  file.close();

  Run run;

  if (!configFile.empty()) {
    fullcommand = PACKAGE_NAME;
    fullcommand += " --config ";
    fullcommand += configFile;
  }

  run.restart(fullcommand);
}

void on_settings_close() { gtk_main_quit(); }

std::string getCommand() {
  std::string command;
  command = PACKAGE_NAME;

  GtkWidget *checkbutton = NULL;
  GtkWidget *spinbutton = NULL;

  checkbutton = glade_xml_get_widget(xml, "checkbutton_bpress");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --bpress";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_above_desk");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --above-desk";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_vbar");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --vbar";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_nofont");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --nofont";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_pos");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --pos";
    GtkWidget *combo = glade_xml_get_widget(xml, "combobox_pos");

    switch ((int) gtk_combo_box_get_active(GTK_COMBO_BOX(combo))) {
    case POS_TOP:
      command += " top";
      break;
    default:
    case POS_BOTTOM:
      command += " bottom";
      break;
    case POS_LEFT:
      command += " left";
      break;
    case POS_RIGHT:
      command += " right";
      break;
    case POS_CENTER:
      command += " center";
      break;
    case POS_BOTTOM_LEFT:
      command += " bot-left";
      break;
    case POS_BOTTOM_RIGHT:
      command += " bot-right";
      break;
    case POS_TOP_LEFT:
      command += " top-left";
      break;
    case POS_TOP_RIGHT:
      command += " top-right";
      break;
    }
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_grow");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --grow";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_offset");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --offset";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_offset");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_noreload");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --noreload";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_taskbar");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --taskbar";
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_rsize");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --rsize";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_rsize");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_isize");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --isize";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_isize");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_idist");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --idist";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_idist");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_nanim");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --nanim";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_nanim");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_zoomf");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --zoomf";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_zoomf");
    sprintf(text, " %f",
            (float) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_jumpf");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --jumpf";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_jumpf");
    sprintf(text, " %f",
            (float) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_dblclk");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --dblclk";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_dblclk");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_balfa");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --balfa";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_balfa");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_falfa");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    char text[10];
    command += " --falfa";
    spinbutton = glade_xml_get_widget(xml, "spinbutton_falfa");
    sprintf(text, " %d",
            (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinbutton)));
    command += text;
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_filter");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    command += " --filter";
    GtkWidget *combo = glade_xml_get_widget(xml, "combobox_filter");

    switch ((int) gtk_combo_box_get_active(GTK_COMBO_BOX(combo))) {
    default:
    case FILTER_NONE:
      command += " 0";
      break;
    case FILTER_HOVERED:
      command += " 1";
      break;
    case FILTER_OTHERS:
      command += " 2";
      break;
    case FILTER_ALL:
      command += " 3";
      break;
    }
  }

  checkbutton = glade_xml_get_widget(xml, "checkbutton_fc");

  if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbutton))) {
    GtkWidget *color = glade_xml_get_widget(xml, "colorbutton_fc");
    GdkColor rgb;
    gchar text[16];

    gtk_color_button_get_color(GTK_COLOR_BUTTON(color), &rgb);
    int alpha = gtk_color_button_get_alpha(GTK_COLOR_BUTTON(color));
    g_snprintf(text, sizeof(text), "0x%02x%02x%02x%02x", alpha >> 8,
               rgb.red >> 8, rgb.green >> 8, rgb.blue >> 8);

    command += " --fc ";
    command += text;
  }

  return command;
}

bool validate() {
  GtkWidget *title = glade_xml_get_widget(xml, "entry_title");
  GtkWidget *command = glade_xml_get_widget(xml, "entry_command");
  GtkWidget *icon = glade_xml_get_widget(xml, "entry_icon");

  std::string text_title, text_command, text_icon;

  text_title = (gchar *)gtk_entry_get_text(GTK_ENTRY(title));
  text_command = (gchar *)gtk_entry_get_text(GTK_ENTRY(command));
  text_icon = (gchar *)gtk_entry_get_text(GTK_ENTRY(icon));

  bool resp = text_title != "" && text_command != "" && text_icon != "";

  if (!resp) {
    GtkWidget *dialog = gtk_message_dialog_new(
        GTK_WINDOW(glade_xml_get_widget(xml, "dialog_settings")),
        GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
        _("Fields must not be empty"));

    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
  }

  return resp;
}

void on_app_accept() {
  if (!validate()) {
    return;
  }

  GtkWidget *title = glade_xml_get_widget(xml, "entry_title");
  GtkWidget *command = glade_xml_get_widget(xml, "entry_command");
  GtkWidget *icon = glade_xml_get_widget(xml, "entry_icon");

  std::string text_title, text_command, text_icon;

  text_title = (gchar *)gtk_entry_get_text(GTK_ENTRY(title));
  text_command = (gchar *)gtk_entry_get_text(GTK_ENTRY(command));
  text_icon = (gchar *)gtk_entry_get_text(GTK_ENTRY(icon));

  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
  GtkListStore *list_store = GTK_LIST_STORE(model);
  GtkTreeIter iter;

  if (!edit) {
    gtk_list_store_append(list_store, &iter);
    gtk_list_store_set(list_store, &iter, TREE_COLUMN_ICON, get_icon(text_icon),
                       TREE_COLUMN_TITLE, text_title.c_str(),
                       TREE_COLUMN_COMMAND, text_command.c_str(),
                       TREE_COLUMN_ICON_NAME, text_icon.c_str(), -1);
  } else {
    GtkTreeSelection *selection =
        gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

    if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
      gtk_list_store_set(
          list_store, &iter, TREE_COLUMN_ICON, get_icon(text_icon),
          TREE_COLUMN_TITLE, text_title.c_str(), TREE_COLUMN_COMMAND,
          text_command.c_str(), TREE_COLUMN_ICON_NAME, text_icon.c_str(), -1);
    }
  }

  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_app");
  gtk_widget_hide(dialog);
}

void on_app_cancel() {
  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_app");
  gtk_widget_hide(dialog);
}

void on_app_up() {
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");

  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
    GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
    GtkTreePath *prev = gtk_tree_path_copy(path);
    gtk_tree_path_prev(prev);

    GtkTreeIter before;
    gtk_tree_model_get_iter(model, &before, prev);
    gtk_list_store_move_before(GTK_LIST_STORE(model), &iter, &before);

    gtk_tree_path_free(path);
    gtk_tree_path_free(prev);
    set_status_button();
  }
}

void on_app_down() {
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");

  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
    GtkTreeIter *next = gtk_tree_iter_copy(&iter);

    gtk_tree_model_iter_next(model, next);
    gtk_list_store_move_after(GTK_LIST_STORE(model), &iter, next);

    gtk_tree_iter_free(next);
    set_status_button();
  }
}

void on_icon_changed() {}

void on_treeview_cursor_changed() { set_status_button(); }

void set_status_button() {
  GtkWidget *treeview = glade_xml_get_widget(xml, "treeview_app");
  GtkWidget *button_edit = glade_xml_get_widget(xml, "button_edit");
  GtkWidget *button_delete = glade_xml_get_widget(xml, "button_delete");
  GtkWidget *button_up = glade_xml_get_widget(xml, "button_up");
  GtkWidget *button_down = glade_xml_get_widget(xml, "button_down");

  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
    GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
    gint *index = gtk_tree_path_get_indices(path);

    if (index) {
      gtk_widget_set_sensitive(button_edit, true);
      gtk_widget_set_sensitive(button_delete, true);
      gtk_widget_set_sensitive(button_up, index[0] > 0);
      gtk_widget_set_sensitive(button_down,
                               gtk_tree_model_iter_next(model, &iter));
      gtk_tree_path_free(path);

      return;
    }

    gtk_tree_path_free(path);

  }

  gtk_widget_set_sensitive(button_edit, false);
  gtk_widget_set_sensitive(button_delete, false);
  gtk_widget_set_sensitive(button_up, false);
  gtk_widget_set_sensitive(button_down, false);
}

gboolean clickTreeView(GtkWidget *widget, GdkEventButton *event,
                       gpointer data) {
  if (event->button == 3) {
    GtkWidget *menu = static_cast<GtkWidget *>(data);
    gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button,
                   event->time);
    return true;
  }

  return false;
}

void on_select_command() {
  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_app");

  GtkWidget *file = gtk_file_chooser_dialog_new(
      _("Open exec file"), GTK_WINDOW(dialog), GTK_FILE_CHOOSER_ACTION_OPEN,
      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
      GTK_RESPONSE_ACCEPT, (char *)NULL);

  GtkWidget *command = glade_xml_get_widget(xml, "entry_command");
  std::string filename = gtk_entry_get_text(GTK_ENTRY(command));
  gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file),
                                filename == "" ? "/usr/bin" : filename.c_str());

  if (gtk_dialog_run(GTK_DIALOG(file)) == GTK_RESPONSE_ACCEPT) {
    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file));
    gtk_entry_set_text(GTK_ENTRY(command), filename.c_str());
  }

  gtk_widget_destroy(file);
}

void on_select_icon() {
  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_app");

  GtkWidget *file = gtk_file_chooser_dialog_new(
      _("Open image file"), GTK_WINDOW(dialog), GTK_FILE_CHOOSER_ACTION_OPEN,
      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
      GTK_RESPONSE_ACCEPT, (char *)NULL);

  GtkWidget *icon = glade_xml_get_widget(xml, "entry_icon");
  GtkFileFilter *filter = gtk_file_filter_new();
  gtk_file_filter_add_pixbuf_formats(filter);
  gtk_file_filter_set_name(filter, _("Images"));

  std::string filename = gtk_entry_get_text(GTK_ENTRY(icon));

  gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file),
                                filename == "" ? PIXMAPDIR : filename.c_str());
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file), filter);

  if (gtk_dialog_run(GTK_DIALOG(file)) == GTK_RESPONSE_ACCEPT) {
    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file));
    gtk_entry_set_text(GTK_ENTRY(icon), filename.c_str());
  }

  gtk_widget_destroy(file);
}

void on_select_fontname() {
  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_settings");

  GtkWidget *file = gtk_file_chooser_dialog_new(
      _("Open font file"), GTK_WINDOW(dialog), GTK_FILE_CHOOSER_ACTION_OPEN,
      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
      GTK_RESPONSE_ACCEPT, (char *)NULL);

  GtkWidget *font = glade_xml_get_widget(xml, "entry_font_name");
  GtkFileFilter *filter = gtk_file_filter_new();
  gtk_file_filter_set_name(filter, _("Fonts"));
  gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.ttf");

  std::string filename = gtk_entry_get_text(GTK_ENTRY(font));

  gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file), filename.c_str());
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file), filter);

  if (gtk_dialog_run(GTK_DIALOG(file)) == GTK_RESPONSE_ACCEPT) {
    Utils util;
    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file));
    filename = util.replace(filename, ".ttf", "");
    gtk_entry_set_text(GTK_ENTRY(font), filename.c_str());
  }

  gtk_widget_destroy(file);
}

void on_select_imagename() {
  GtkWidget *dialog = glade_xml_get_widget(xml, "dialog_settings");

  GtkWidget *file = gtk_file_chooser_dialog_new(
      _("Open image file"), GTK_WINDOW(dialog), GTK_FILE_CHOOSER_ACTION_OPEN,
      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
      GTK_RESPONSE_ACCEPT, (char *)NULL);

  GtkWidget *icon = glade_xml_get_widget(xml, "entry_image_name");
  GtkFileFilter *filter = gtk_file_filter_new();
  gtk_file_filter_add_pixbuf_formats(filter);
  gtk_file_filter_set_name(filter, _("Images"));

  std::string filename = gtk_entry_get_text(GTK_ENTRY(icon));

  gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file), filename.c_str());
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file), filter);

  if (gtk_dialog_run(GTK_DIALOG(file)) == GTK_RESPONSE_ACCEPT) {
    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file));
    gtk_entry_set_text(GTK_ENTRY(icon), filename.c_str());
  }

  gtk_widget_destroy(file);
}

void checkbutton_toggled(GtkToggleButton *togglebutton, gpointer data) {
  GtkWidget *widget = static_cast<GtkWidget *>(data);
  gtk_widget_set_sensitive(widget, gtk_toggle_button_get_active(togglebutton));
}

gboolean widget_hide(GtkWidget *widget, GdkEvent *event, gpointer data) {
  gtk_widget_hide(widget);
  return true;
}

void show_about() {
  GdkPixbuf *pixbuf;
  pixbuf = gdk_pixbuf_new_from_file(ICON_DEFAULT, NULL);

  GtkWidget *settings = glade_xml_get_widget(xml, "dialog_settings");

  gtk_show_about_dialog(
      gtk_widget_get_tooltip_window(settings), "title", _("About"), "icon",
      pixbuf, "program-name", _("wbar config"), "version", VERSION, "copyright",
      _("License GPL - 2010"), "comments", _("A light and fast launch bar."),
      "website", "http://code.google.com/p/wbar/", "website-label",
      _("wbar project website"), "authors", authors, "documenters", documenters,
      "translator-credits", translater, "logo", pixbuf, (char *)NULL);
}
